

//#define I1 (((~CopyPIN[1] & (1<<PORTC5))>>PORTC5) & 0x01)
//#define I2 (((~CopyPIN[1] & (1<<PORTC4))>>PORTC4) & 0x01)
#define O1 (1<<PORTD4)
#define O2 (1<<PORTD6)




 //===================================================== Configuration ============================================
       	  	  
      volatile int NB_etapes = 3;
      volatile int dim_tab_etape = ((int)(NB_etapes /8)+1);
      volatile byte* tab_etape = (volatile byte * )malloc(dim_tab_etape);
      //Configuration transition
      volatile int r1 =0;
      volatile int r2 =0;
      // définition des variables
      volatile byte CopyPIN[3];
      volatile byte SORT[3];
      volatile byte ENT[3] ;
      volatile byte CmdSort[3];
      volatile byte* Copie_etape = (volatile byte*)malloc(dim_tab_etape);
      volatile byte* Etat_fin = (volatile byte*)malloc(dim_tab_etape);
																						  // variable du timer 
																						  int var1;
																						  int Enable1;
 
 // ======================================================= interuption Timer ===================================================== 
														   ISR(TIMER2_COMPA_vect){
															 
															 if (var1 >0) 
															 {
															  var1 = var1 -1;
															 }
															 
															 
														   }
  
   
    
// ======================================================= SETUP =====================================================

void setup(){
																					// config timer
																					TCCR2A = B010;
																					OCR2A = 156;
																					TCCR2B = B111;
																					TIMSK2= B010;
															// init var timer
															var1 = 0;
        
                    
        tab_etape[0] = B00000001;
        
        for( int i = 0 ; i < 3; i++)
        {
          SORT[i] = B00000000;
          ENT[i] = B11111111;
          CmdSort[i] = B00000000;
        }
  
  // ------initialisation des sorties----
      // écriture des variable de sortie:
          //variable de sortie port B
         
           set_bit(SORT,0,1,1);
          //...
          //variable de sortie port C
          //...
          //variable de sortie port D
         
          set_bit(SORT,2,4,1);
          set_bit(SORT,2,5,1);
          set_bit(SORT,2,6,1);
          //...    
      // intialisation des port en sortie
          
          DDRB |= SORT[0];
          DDRC |= SORT[1];
          DDRD |= SORT[2];  
 //------fin initialisation des sorties -----  
   
          
          
  //------ Configuration des entree -----
  
		  //variable de entrée port B
           //...
          //variable de entrée port C
          set_bit(ENT,1,5,0); 
          set_bit(ENT,1,4,0);		
          //variable de entrée port D
		  //...
		
			DDRB &= ENT[0];
			DDRC &= ENT[1];
			DDRD &= ENT[2];
			
  //------ fin Configuration des entree -----

  //------écriture des sorties en initialisation (si besoin)-----
        PORTC |= 0x30;
  //------------------fin écriture des sorties -----------
  
 
}




void loop()                     
{
 
      //-----------Lecture de toutes les entrées (Copie)-------
        
          // premier principe automate: lire les entrèes.
          CopyPIN[0] = PINB;
          CopyPIN[1] = PINC;
          CopyPIN[2] = PIND;    
          //--------- repérage des receptivités  -------
           r1=!get_bit(CopyPIN,1,5); 
           r2=!get_bit(CopyPIN,1,4);
           //------------Structure graphcet --------------
           structure_G7();
           //------------ fin Structure graphcet --------------
                            
                 
         if ( get_bit(tab_etape,0,0) ==1)
        	  {		 
                     // a faire ici ou en "ecriture des Sortie"
                     // initialisation des variable de sortie
                    set_bit(CmdSort,2,4,1);
                     set_bit(CmdSort,2,6,0); 
                     // fin initialisation des variable de sortie 
        	  }
          
          if ( get_bit(tab_etape,0,2) ==1)
        	  {
                      // a faire ici ou en "ecriture des Sortie"
                      // initialisation des variable de sortie 
                      set_bit(CmdSort,2,6,1);
                      set_bit(CmdSort,2,4,0);
                      // fin initialisation des variable de sortie     
        	  }
              
          //----------------ecriture des Sortie -------------
          // /!\ fonctionnement monostable /!\ remet toutes lses sortie à zéro ne prend pas en compte les états initiaux des sorties .. erreur.TXT chap1
              
          PORTB = (PORTB & (~SORT[0])) | (SORT[0] & CmdSort[0]);
          PORTC = (PORTC & (~SORT[1])) | (SORT[1] & CmdSort[1]); 
          PORTD = (PORTD & (~SORT[2])) | (SORT[2] & CmdSort[2]);
        
}

// fonction de la sctructur du G7
void structure_G7()
{
                   
          copyTab(tab_etape,Etat_fin,dim_tab_etape);
          byte diff = false;
	  do {      
                 copyTab(Etat_fin,Copie_etape,dim_tab_etape);
                 diff = false;
                 
				 if( get_bit(Copie_etape,0,0) && r1)
        		  {        		  
        		      set_bit(Etat_fin,0,0,0);
        		      set_bit(Etat_fin,0,1,1);
					  cli();
					  var1=200; 
						var2=100;
					  sei();
					  
					  Enable1 = 1;      
        		  }      
													  // ici on regarde le timer
													  if( get_bit(Copie_etape,0,1) && var1 == 0 && Enable1 == 1)
													  {        		  
														  set_bit(Etat_fin,0,1,0);
														  set_bit(Etat_fin,0,2,1);
																  Enable1 = 0;      
													  }
        
                  if( get_bit(Copie_etape,0,2) && r2 )
        		  {
        		      set_bit(Etat_fin,0,0,1);
        		      set_bit(Etat_fin,0,2,0);    
        		  }

                  int j  = 0;
                  
                  do
                      {
                          diff = Copie_etape[j] != Etat_fin[j] ;
                          j= j+1;
                      }while (j<dim_tab_etape && diff == false);
              
	      }while(diff);
	  
	  for (int i = 0;i < dim_tab_etape ;i=i+1)
              {
                 tab_etape[i] = Etat_fin[i];
              }
         
         copyTab(Etat_fin,tab_etape,dim_tab_etape); 
         
         return;
}



void set_bit(volatile byte* p, int num_case, char num_Bit, int valeur)
{
	if (valeur == 1)
        	{
        	    p[num_case] |= 1<<num_Bit;;
        	    return;
        	}
	else if  (valeur == 0)
        	{
        	    p[num_case] &= ~(1<<num_Bit);
                    return;
        	}	
}
 
 byte get_bit(volatile byte* p,int num_case, char num_Bit){
	return (p[num_case]>>num_Bit) & 0x0001;
}

void copyTab(volatile byte* tabSrc, volatile byte* tabDst,int dim)
{
       for(int i = 0; i < dim; i++)
           {
              tabDst[i]=tabSrc[i];
           }
}

